﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SGT_DAL._STG_DALTableAdapters;
using SGT_DAL;

namespace SGT_ON
{
    ///ESTADOS DE LA TAREA
    /// - En espera
    /// - Pausa
    /// - Finalizada
    /// - Cancelada
    /// - En ejecución
    /// 
    
    /// <summary>
    /// Clase utilizada para la presentación y propiedades derivadas.
    /// </summary>
    public partial class ONTareaLineaDeTiempo
    {
        /// <summary>
        /// Estado inicial del objeto.
        /// </summary>
        public static string EstadoInicial
        {
            get
            {
                return "En espera";
            }
        }

        #region Propiedades derivadas
        public string EmpleadoResponsableApellidoYNombre
        {
            get
            {
                return EmpleadoResponsable.ApellidoYNombre;
            }
        }
        public string SectorNombre
        {
            get
            {
                return Sector.Nombre;
            }
        }
        public string PresupuestoPatente
        {
            get
            {
                return LineaDeTiempo.Presupuesto.Patente;
            }
        }
        public string PresupuestoFechaDeEntregaEstimada
        {
            get
            {
                if (LineaDeTiempo.Presupuesto.FechaEntregaEstimada.HasValue == true)
                    return LineaDeTiempo.Presupuesto.FechaEntregaEstimada.Value.ToString("dd/MM/yyyy");
                else
                    return "";
            }
        }
        #endregion

        #region Propiedades como string
        public string FechaFinRealString
        {
            get
            {
                if (FechaFinReal.HasValue == true)
                    return FechaFinReal.Value.ToString("dd/MM/yyyy HH:mm");
                else
                    return "";
            }
        }
        public string FechaInicioRealString
        {
            get
            {
                if (FechaInicioReal.HasValue == true)
                    return FechaInicioReal.Value.ToString("dd/MM/yyyy HH:mm");
                else
                    return "";
            }
        }
        #endregion
    }
    /// <summary>
    /// Clase base con la lógica de negocio
    /// </summary>
    [System.ComponentModel.DataObject]
    public partial class ONTareaLineaDeTiempo
    {
        #region Estados 
        public enum Estados
        {
            En_espera,
            Pausa,
            Finalizada,
            Cancelada,
            En_ejecución
        }
        #endregion 

        #region Atributos
        protected int _id;
        protected int? _elementoId;
        protected string _estado;
        protected DateTime? _fechaInicioReal;
        protected DateTime? _fechaFinReal;
        protected int _lineaDeTiempoId;
        protected string _nombre;
        protected string _observaciones;
        protected int _orden;
        protected double _tiempoEstimadoHoras;
        protected int _sectorId;
        protected int _empleadoIdResponsable;
        
        //Objetos asociados
        protected ONEmpleado _empleadoResponsable;
        protected ONSector _sector;
        protected ONInterrupcionColeccion _interrupciones;
        protected ONLineaDeTiempo _lineaDeTiempo;
        #endregion

        #region Propiedades
        public int ID
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }
        public int? ElementoId
        {
            get
            {
                return _elementoId;
            }
            set
            {
                _elementoId = value;
            }
        }
        public string Estado
        {
            get
            {
                return _estado;
            }
            set
            {
                _estado = value;
            }
        }
        public DateTime? FechaInicioReal
        {
            get
            {
                return _fechaInicioReal;
            }
            set
            {
                _fechaInicioReal = value;
            }
        }
        public DateTime? FechaFinReal
        {
            get
            {
                return _fechaFinReal;
            }
            set
            {
                _fechaFinReal = value;
            }
        }
        public int LineaDeTiempoId
        {
            get
            {
                return _lineaDeTiempoId;
            }
            set
            {
                _lineaDeTiempoId = value;
            }
        }
        public string Nombre
        {
            get
            {
                return _nombre;
            }
            set
            {
                _nombre = value;
            }
        }
        public string Observaciones
        {
            get
            {
                return _observaciones;
            }
            set
            {
                _observaciones = value;
            }
        }
        public int Orden
        {
            get
            {
                return _orden;
            }
            set
            {
                _orden = value;
            }
        }
        public double TiempoEstimadoHoras
        {
            get
            {
                return _tiempoEstimadoHoras;
            }
            set
            {
                _tiempoEstimadoHoras = value;
            }
        }
        public int SectorId
        {
            get
            {
                return _sectorId;
            }
            set
            {
                _sectorId = value;
            }
        }
        public int EmpleadoIdResponsable
        {
            get
            {
                return _empleadoIdResponsable;
            }
            set
            {
                _empleadoIdResponsable = value;
            }
        }  

        //Objetos asociados
        public ONEmpleado EmpleadoResponsable
        {
            get
            {
                if (EmpleadoIdResponsable > 0)
                {
                    if ((_empleadoResponsable != null)
                        && (_empleadoResponsable.ID == EmpleadoIdResponsable))
                        return _empleadoResponsable;//si ya esta cargado, lo devuelvo
                    else
                        _empleadoResponsable = ONEmpleado.CrearEmpleado(_empleadoIdResponsable);
                }
                else
                {
                    _empleadoResponsable = new ONEmpleado();
                }
                return _empleadoResponsable;
            }
        }
        public ONSector Sector
        {
            get
            {
                if (SectorId > 0)
                {
                    if ((_sector != null)
                        && (_sector.ID == SectorId))
                        return _sector;//si ya esta cargado, lo devuelvo
                    else
                        _sector = ONSector.CrearSector(_sectorId);
                }
                else
                {
                    _sector = new ONSector();
                }
                return _sector;
            }
        }
        public ONInterrupcionColeccion Interrupciones
        {
            get
            {
                if (_interrupciones == null)
                    _interrupciones = ONInterrupcion.ObtenerInterrupcionesDeTareaLineaDeTiempoDAL(ID);
                return _interrupciones;
            }
            set
            {
                _interrupciones = value;
            }
        }
        public ONLineaDeTiempo LineaDeTiempo
        {
            get
            {
                if ((_lineaDeTiempo == null)
                    || (_lineaDeTiempo.ID != LineaDeTiempoId))
                    _lineaDeTiempo = ONLineaDeTiempo.CrearLineaDeTiempo(LineaDeTiempoId);

                return _lineaDeTiempo;
            }
        }

        
        #endregion

        #region Validaciones
        /// <summary>
        /// Indica si la tarea se puede iniciar.
        /// </summary>
        public bool PuedeIniciar
        {
            get
            {
                // si no tengo interrupciones, se puede iniciar
                if (Interrupciones.Count == 0)
                    return true;

                //si tengo una interrupcion abierta, no puedo iniciar.
                foreach (ONInterrupcion _interrupcion in Interrupciones)
                {
                    if (_interrupcion.FechaHoraFin.HasValue == false)
                        return false;
                }

                return true;
            }
        }
        public bool PuedePausar
        {
            get
            {
                //si tengo una interrupcion abierta, puedo pausar.
                foreach (ONInterrupcion _interrupcion in Interrupciones)
                {
                    if (_interrupcion.FechaHoraFin.HasValue == false)
                        return true;
                }
                return false;
            }
        }
        #endregion

        #region Interfase DAL
        //objeto de la capa DAL
        private static TareaLineaDeTiempoTableAdapter _tareaLineaDeTiempoAD;
        protected static TareaLineaDeTiempoTableAdapter Adaptador
        {
            get
            {
                if (_tareaLineaDeTiempoAD == null)
                    _tareaLineaDeTiempoAD = new TareaLineaDeTiempoTableAdapter();

                return _tareaLineaDeTiempoAD;
            }
        }
        protected static ONTareaLineaDeTiempo ObtenerPorID(int pID)
        {   
            _STG_DAL.TareaLineaDeTiempoDataTable _dt;

            _dt = Adaptador.ObtenerPorId(pID);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                return AsignarRowAObjeto((_STG_DAL.TareaLineaDeTiempoRow)_dt.Rows[0]);

            return null;
        }
        protected static ONTareaLineaDeTiempo AsignarRowAObjeto(_STG_DAL.TareaLineaDeTiempoRow pRow)
        {
            ONTareaLineaDeTiempo _tareaLineaDeTiempo = new ONTareaLineaDeTiempo();
            if (pRow != null)
            {
                _tareaLineaDeTiempo = new ONTareaLineaDeTiempo();
                
                _tareaLineaDeTiempo.ID = pRow.ID;
                
                if (pRow.IsElementoIdNull())
                    _tareaLineaDeTiempo.ElementoId = null;
                else
                    _tareaLineaDeTiempo.ElementoId = pRow.ElementoId;

                _tareaLineaDeTiempo.Estado = pRow.Estado;

                if (pRow.IsFechaInicioRealNull())
                    _tareaLineaDeTiempo.FechaInicioReal = null;
                else
                    _tareaLineaDeTiempo.FechaInicioReal = pRow.FechaInicioReal;

                if (pRow.IsFechaFinRealNull())
                    _tareaLineaDeTiempo.FechaFinReal = null;
                else
                    _tareaLineaDeTiempo.FechaFinReal = pRow.FechaFinReal;

                _tareaLineaDeTiempo.LineaDeTiempoId = pRow.LineaDeTiempoId;

                _tareaLineaDeTiempo.Nombre = pRow.Nombre;

                _tareaLineaDeTiempo.Observaciones = pRow.Observaciones;

                _tareaLineaDeTiempo.Orden = pRow.Orden;

                _tareaLineaDeTiempo.TiempoEstimadoHoras = pRow.TiempoEstimadoHoras;

                _tareaLineaDeTiempo.SectorId = pRow.SectorId;

                _tareaLineaDeTiempo.EmpleadoIdResponsable = pRow.EmpleadoIdResponsable;
            }
            return _tareaLineaDeTiempo;
        }
        protected ONTareaLineaDeTiempo InsertarDAL(int? pElementoId, string pEstado, DateTime? pFechaFinReal, DateTime? pFechaInicioReal, int pLineaDeTiempoId, string pNombre, string pObservaciones, int pOrden, double pTiempoEstimadoHoras, int pSectorId, int pEmpleadoIdResponsable)
        {
            ID = int.Parse(Adaptador.Insertar(pElementoId, pEstado, pFechaFinReal, pFechaInicioReal, pLineaDeTiempoId, pNombre, pObservaciones, pOrden, pTiempoEstimadoHoras, pSectorId, pEmpleadoIdResponsable).ToString());
            return this;
        }
        protected bool ActualizarDAL(int? pElementoId, string pEstado, DateTime? pFechaFinReal, DateTime? pFechaInicioReal, int pLineaDeTiempoId, string pNombre, string pObservaciones, int pOrden, double pTiempoEstimadoHoras, int pSectorId, int pEmpleadoIdResponsable, int pId)
        {
            if (0 < Adaptador.Actualizar(pElementoId, pEstado, pFechaFinReal, pFechaInicioReal, pLineaDeTiempoId, pNombre, pObservaciones, pOrden, pTiempoEstimadoHoras, pSectorId, pEmpleadoIdResponsable, pId))
                return true;
            else
                return false;
        }
        public static void EliminarDAL(int pID)
        {
            if (Adaptador.Eliminar(pID) == 0)
                throw new ArgumentException("La tarea no existe.");
        }
        protected static ONTareaLineaDeTiempoColeccion AsignarTareaLineaDeTiempoTableAdapterATareaLineaDeTiempoColeccion(_STG_DAL.TareaLineaDeTiempoDataTable pDataTable)
        {
            ONTareaLineaDeTiempoColeccion _tareaLineaDeTiempos = new ONTareaLineaDeTiempoColeccion();
            ONTareaLineaDeTiempo _tareaLineaDeTiempo;

            if ((pDataTable != null)
                && (pDataTable.Rows.Count > 0))
            {
                foreach (_STG_DAL.TareaLineaDeTiempoRow _row in pDataTable.Rows)
                {
                    _tareaLineaDeTiempo = AsignarRowAObjeto(_row);
                    if (_tareaLineaDeTiempo != null)
                        _tareaLineaDeTiempos.Add(_tareaLineaDeTiempo);
                }
            }
            return _tareaLineaDeTiempos;
        }
        public static ONTareaLineaDeTiempoColeccion ObtenerTodosLosTareaLineaDeTiemposDAL(int pLineaDeTiempoId)
        {
            return AsignarTareaLineaDeTiempoTableAdapterATareaLineaDeTiempoColeccion(Adaptador.ObtenerTareasLineasDeTiempoDeLineaDeTiempo(pLineaDeTiempoId));
        }
        public static ONTareaLineaDeTiempoColeccion ObtenerTareasDePresupuesto(int pPresupuestoId)
        {
            return AsignarTareaLineaDeTiempoTableAdapterATareaLineaDeTiempoColeccion(Adaptador.ObtenerTareasDePresupuesto(pPresupuestoId));
        }
        public static ONTareaLineaDeTiempo ObtenerPorOrden(int pLineaDeTiempoId, int pOrden)
        {
            _STG_DAL.TareaLineaDeTiempoDataTable _dt;

            _dt = Adaptador.ObtenerPorOrden(pLineaDeTiempoId, pOrden);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                return AsignarRowAObjeto((_STG_DAL.TareaLineaDeTiempoRow)_dt.Rows[0]);

            return null;
        }
        public static ONTareaLineaDeTiempoColeccion ObtenerTareasActivasDeEmpleado(int pEmpleadoId)
        {
            if (pEmpleadoId <= 0)
                return new ONTareaLineaDeTiempoColeccion();

            return AsignarTareaLineaDeTiempoTableAdapterATareaLineaDeTiempoColeccion(Adaptador.ObtenerTareasActivasDeEmpleado(pEmpleadoId));
        }
        public enum OrdenAccion
        {
            Subir,
            Bajar
        }
        public static bool CambiarOrdenDeTarea(int pTareaLineaDeTiempoId, OrdenAccion pAccion)
        {
            ONTareaLineaDeTiempo _tareaLT = ONTareaLineaDeTiempo.ObtenerPorID(pTareaLineaDeTiempoId);
            if ((_tareaLT == null)
                || (_tareaLT.ID < 0))
                throw new ArgumentException("El registro no existe");

            
            ONTareaLineaDeTiempo _tareaLT2;
            if (pAccion == OrdenAccion.Bajar)
                _tareaLT2 = ONTareaLineaDeTiempo.ObtenerTareaSiguientePorOrden(_tareaLT.LineaDeTiempoId, _tareaLT.Orden);
            else
                _tareaLT2 = ONTareaLineaDeTiempo.ObtenerTareaAnteriorPorOrden(_tareaLT.LineaDeTiempoId, _tareaLT.Orden);

            //ONTareaLineaDeTiempo _tareaLT2 = ONTareaLineaDeTiempo.ObtenerPorOrden(_tareaLT.LineaDeTiempoId, _aux);
            if (_tareaLT2 == null) // en el caso que sea la ultima, me va a devolver nulo o si es la unica tambien por lo que no hago nada.
                return true;
            
            int _aux = _tareaLT.Orden;

            _tareaLT.Orden = _tareaLT2.Orden;

            _tareaLT2.Orden = _aux;

            _tareaLT.Actualizar();
            _tareaLT2.Actualizar();

            return true;
        }
        /// <summary>
        /// Devuelve el orden menor de tareas que tiene la linea de tiempo
        /// </summary>
        /// <param name="pLineaDeTiempoId"></param>
        /// <returns></returns>
        public static int ObtenerOrdenMenor(int pLineaDeTiempoId)
        {
            int? _Orden = Adaptador.ObtenerOrdenMenor(pLineaDeTiempoId);
            if (_Orden.HasValue == false)
                return 0; //Significa que noo tengo ninguna tarea
            else
                return _Orden.Value;
        }
        /// <summary>
        /// Devuelve la tarea anterior al orden especificado
        /// </summary>
        /// <param name="pLineaDeTiempoId"></param>
        /// <param name="pOrden"></param>
        /// <returns>ONTareaLineaDeTiempo o Nulo</returns>
        public static ONTareaLineaDeTiempo ObtenerTareaAnteriorPorOrden(int pLineaDeTiempoId,int pOrden)
        {
            _STG_DAL.TareaLineaDeTiempoDataTable _dt;

            _dt = Adaptador.ObtenerTareaAnteriorPorOrden(pLineaDeTiempoId, pOrden);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                return AsignarRowAObjeto((_STG_DAL.TareaLineaDeTiempoRow)_dt.Rows[0]);

            return null;
        }
        /// <summary>
        /// Devuelve la tarea siguiente al orden especidicado
        /// </summary>
        /// <param name="pLineaDeTiempoId"></param>
        /// <param name="pOrden"></param>
        /// <returns>ONTareaLineaDeTiempo o Nulo</returns>
        public static ONTareaLineaDeTiempo ObtenerTareaSiguientePorOrden(int pLineaDeTiempoId, int pOrden)
        {
            _STG_DAL.TareaLineaDeTiempoDataTable _dt;

            _dt = Adaptador.ObtenerTareaSiguientePorOrden(pLineaDeTiempoId, pOrden);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                return AsignarRowAObjeto((_STG_DAL.TareaLineaDeTiempoRow)_dt.Rows[0]);

            return null;
        }
        #endregion

        #region Métodos
        public ONTareaLineaDeTiempo()
        {
            AsignarValoresIniciales();
        }

        public void AsignarValoresIniciales()
        {
            _id = -1;
            ElementoId = -1; // null;
            Estado = "En ejecución";
            FechaInicioReal = null;
            FechaFinReal = null;
            LineaDeTiempoId = -1;
            Nombre = "";
            Observaciones = "";
            Orden = 0;
            TiempoEstimadoHoras = 0;
            EmpleadoIdResponsable = -1;
        }

        public static ONTareaLineaDeTiempo CrearTareaLineaDeTiempo()
        {
            ONTareaLineaDeTiempo _tareaLineaDeTiempo = new ONTareaLineaDeTiempo();
            return _tareaLineaDeTiempo;
        }
        public static ONTareaLineaDeTiempo CrearTareaLineaDeTiempo(int pID)
        {
            ONTareaLineaDeTiempo _tareaLineaDeTiempo = ObtenerPorID(pID);
            return _tareaLineaDeTiempo;
        }
        public ONTareaLineaDeTiempo Insertar()
        {
            return InsertarDAL(ElementoId, Estado, FechaFinReal, FechaInicioReal, LineaDeTiempoId, Nombre, Observaciones, Orden, TiempoEstimadoHoras, SectorId, EmpleadoIdResponsable);
        }
        public bool Actualizar()
        {
            return ActualizarDAL(ElementoId, Estado, FechaFinReal, FechaInicioReal, LineaDeTiempoId, Nombre, Observaciones, Orden, TiempoEstimadoHoras, SectorId, EmpleadoIdResponsable, ID);
        }

        #region Metodos de comportamiento
        /// <summary>
        /// Devuelve la ultima interrupcion activa. En caso que no exista, crea una nueva.
        /// </summary>
        public ONInterrupcion InterrupcionUltimaActiva
        {
            get
            {
                // la creo por si no existe
                ONInterrupcion _resultado = new ONInterrupcion();
                _resultado.TareaLineaDeTiempoId = ID;
                
                foreach(ONInterrupcion _interupcion in Interrupciones)
                {//busco la interrupción que esté abierta(q no tenga fecha de finalización).
                    if (_interupcion.FechaHoraFin.HasValue == false)
                        _resultado = _interupcion;
                }

                return _resultado;
            }
        }
        /// <summary>
        /// Es inicio o continuar tarea
        /// </summary>
        /// <param name="pFechaHoraInicio"></param>
        /// <returns></returns>
        public ONInterrupcion IniciarTarea(DateTime pFechaHoraInicio)
        {
            //si no tiene ninguna interrupción, significa que se esta iniciando la tarea y le pongo la fecha de inicio real.
            if(Interrupciones.Count == 0)
                FechaInicioReal = DateTime.Now;

            Estado = Estados.En_ejecución.ToString().Replace("_", " ");
            
            Actualizar();
            
            // inicio o continuar
            ONInterrupcion _interrupcion = new ONInterrupcion();
            _interrupcion.TareaLineaDeTiempoId = ID;
            _interrupcion.Motivo = "Inicio de tarea";
            _interrupcion.FechaHoraInicio = pFechaHoraInicio;
            return _interrupcion.Insertar();
        }
        public ONInterrupcion PausarTarea(string pMotivoPausa, DateTime pFechaHoraPausa)
        {
            Estado = Estados.Pausa.ToString();
            Actualizar();

            ONInterrupcion _interrupcion =  InterrupcionUltimaActiva;

            if (_interrupcion.ID <= 0)
                return null;

            _interrupcion.FechaHoraFin = pFechaHoraPausa;
            _interrupcion.Motivo = pMotivoPausa;
            _interrupcion.Actualizar();
            return _interrupcion;
        }
        /// <summary>
        /// solo es posible cuando se haya completado.
        /// </summary>
        /// <param name="pMotivo"></param>
        /// <param name="pFechaDeFinalizacion"></param>
        /// <returns></returns>
        public ONInterrupcion FinalizarTarea(string pMotivo, DateTime pFechaDeFinalizacion)
        {
            Estado = Estados.Finalizada.ToString();
            FechaFinReal = pFechaDeFinalizacion;
            Actualizar();

            ONInterrupcion _interrupcion = InterrupcionUltimaActiva;

            if (_interrupcion.ID <= 0)
                return null;

            _interrupcion.FechaHoraFin = pFechaDeFinalizacion;
            _interrupcion.Motivo = pMotivo;
            _interrupcion.Actualizar();
            return _interrupcion;
        }
        public void CancelarTarea(string pMotivo, DateTime pFechaDeFinalizacion)
        {
            Estado = Estados.Cancelada.ToString();
            Actualizar();

            ONInterrupcion _interrupcion = InterrupcionUltimaActiva;

            if (_interrupcion.ID <= 0)
                return;

            _interrupcion.FechaHoraFin = pFechaDeFinalizacion;
            _interrupcion.Motivo = pMotivo;
            _interrupcion.Actualizar();
        }
        #endregion
        #endregion

        #region Metodos para datasource
        public void Actualizar(ONTareaLineaDeTiempo pTareaLineaDeTiempo)
        {
            if (pTareaLineaDeTiempo != null)
                pTareaLineaDeTiempo.Actualizar();
        }
        public ONTareaLineaDeTiempo Insertar(ONTareaLineaDeTiempo pTareaLineaDeTiempo)
        {
            if (pTareaLineaDeTiempo != null)
                return pTareaLineaDeTiempo.Insertar();
            return null;
        }
        public void Eliminar(ONTareaLineaDeTiempo pTareaLineaDeTiempo)
        {
            ONTareaLineaDeTiempo.EliminarDAL(pTareaLineaDeTiempo.ID);
        }
        public void Eliminar(int pTareaLineaDeTiempoID)
        {
            ONTareaLineaDeTiempo.EliminarDAL(pTareaLineaDeTiempoID);
        }
        #endregion
    }
    [System.ComponentModel.DataObject]
    public class ONTareaLineaDeTiempoColeccion : System.Collections.CollectionBase
    {
        public void Add(ONTareaLineaDeTiempo pTareaLineaDeTiempo)
        {
            this.List.Add(pTareaLineaDeTiempo);
        }
        public void AddUnico(ONTareaLineaDeTiempo pTareaLineaDeTiempo)
        {
            foreach (ONTareaLineaDeTiempo _tareaLineaDeTiempo in this)
                if (pTareaLineaDeTiempo.ID == _tareaLineaDeTiempo.ID)
                    return;
            this.List.Add(pTareaLineaDeTiempo);
        }
        public void Remove(int index)
        {
            if (index <= Count - 1 || index >= 0)
            {
                this.List.RemoveAt(index);
            }
            else
            {
                throw new System.ArgumentException("Fuera de rango", "original");
            }
        }
        public void Remove(ONTareaLineaDeTiempo pTareaLineaDeTiempo)
        {
            for (int i = 0; i < this.Count; i++)
            {
                if (this[i].ID == pTareaLineaDeTiempo.ID)
                {
                    Remove(i);
                    return;
                }

            }
        }
        public ONTareaLineaDeTiempo this[int index]
        {
            get { return ((ONTareaLineaDeTiempo)(this.List[index])); }
            set { this.List[index] = value; }
        }
        
        #region Metodos de colección
        
        #endregion
        #region Para datasource
        
        #endregion

        #region Metodos para Sort
        //http://unboxedsolutions.com/sean/archive/2004/08/10/292.aspx
        public void OrdenarPorSector()
        {
            System.Collections.IComparer sorter = new SectorOrdenarHelper();
            InnerList.Sort(sorter);
        }
        private class SectorOrdenarHelper : System.Collections.IComparer
        {
            
            public int Compare(object x, object y)
            {

                ONTareaLineaDeTiempo o1 = (ONTareaLineaDeTiempo)x;

                ONTareaLineaDeTiempo o2 = (ONTareaLineaDeTiempo)y;
                
                //si son iguales le devuelvo 0;
                if (o1.SectorId == o2.SectorId)
                    return 0;

                if (o1.SectorId == Parametros.SectorIdChaperia)
                    return 1;

                if ((o1.SectorId == Parametros.SectorIdPintura) //verifico que el 1 es pintura y el 2 no es Chaperia, entonces es mayor
                    && (o2.SectorId != Parametros.SectorIdChaperia))
                    return 1;

                //si no se dan ninguna de las dos anteriores, significa que es menor.
                return -1;
            }
            
        }
        #endregion
    }
}
